/*******************************************************************************
* Copyright (c) 2000, 2010 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.swt.widgets;
import org.eclipse.swt.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.internal.Compatibility;
/**
* Instances of this class represent a selectable user interface object
* that represents a hierarchy of tree items in a tree widget.
*
* <dl>
* <dt><b>Styles:</b></dt>
* <dd>(none)</dd>
* <dt><b>Events:</b></dt>
* <dd>(none)</dd>
* </dl>
* <p>
* IMPORTANT: This class is <em>not</em> intended to be subclassed.
* </p>
*
* @see <a href="http://www.eclipse.org/swt/snippets/#tree">Tree, TreeItem, TreeColumn snippets</a>
* @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
* @noextend This class is not intended to be subclassed by clients.
*/
public class TreeItem extends Item {
Tree parent;
TreeItem parentItem;
TreeItem[] items = Tree.NO_ITEMS;
int availableIndex = -1; /* index in parent's flat list of available (though not necessarily within viewport) items */
int depth = 0; /* cached for performance, does not change after instantiation */
boolean checked, grayed, expanded, cached;
String[] texts;
int[] textWidths = new int [1]; /* cached string measurements */
int customWidth = -1; /* width specified by Measure callback */
int fontHeight; /* cached item font height */
int[] fontHeights;
Image[] images;
Color foreground, background;
String[] displayTexts;
Color[] cellForegrounds, cellBackgrounds;
Font font;
Font[] cellFonts;
static final int INDENT_HIERARCHY = 6; /* the margin between an item's expander and its checkbox or content */
static final int MARGIN_TEXT = 3; /* the left and right margins within the text's space */
/**
* Constructs a new instance of this class given its parent
* (which must be a <code>Tree</code> or a <code>TreeItem</code>)
* and a style value describing its behavior and appearance.
* The item is added to the end of the items maintained by its parent.
* <p>
* The style value is either one of the style constants defined in
* class <code>SWT</code> which is applicable to instances of this
* class, or must be built by <em>bitwise OR</em>'ing together
* (that is, using the <code>int</code> "|" operator) two or more
* of those <code>SWT</code> style constants. The class description
* lists the style constants that are applicable to the class.
* Style bits are also inherited from superclasses.
* </p>
*
* @param parent a tree control which will be the parent of the new instance (cannot be null)
* @param style the style of control to construct
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_NULL_ARGUMENT - if the parent is null</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li>
* <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li>
* </ul>
*
* @see SWT
* @see Widget#checkSubclass
* @see Widget#getStyle
*/
public TreeItem (Tree parent, int style) {
this (parent, style, checkNull (parent).items.length);
}
/**
* Constructs a new instance of this class given its parent
* (which must be a <code>Tree</code> or a <code>TreeItem</code>),
* a style value describing its behavior and appearance, and the index
* at which to place it in the items maintained by its parent.
* <p>
* The style value is either one of the style constants defined in
* class <code>SWT</code> which is applicable to instances of this
* class, or must be built by <em>bitwise OR</em>'ing together
* (that is, using the <code>int</code> "|" operator) two or more
* of those <code>SWT</code> style constants. The class description
* lists the style constants that are applicable to the class.
* Style bits are also inherited from superclasses.
* </p>
*
* @param parent a tree control which will be the parent of the new instance (cannot be null)
* @param style the style of control to construct
* @param index the zero-relative index to store the receiver in its parent
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_NULL_ARGUMENT - if the parent is null</li>
* <li>ERROR_INVALID_RANGE - if the index is not between 0 and the number of elements in the parent (inclusive)</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li>
* <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li>
* </ul>
*
* @see SWT
* @see Widget#checkSubclass
* @see Widget#getStyle
*/
public TreeItem (Tree parent, int style, int index) {
this (parent, style, index, true);
}
/**
* Constructs a new instance of this class given its parent
* (which must be a <code>Tree</code> or a <code>TreeItem</code>)
* and a style value describing its behavior and appearance.
* The item is added to the end of the items maintained by its parent.
* <p>
* The style value is either one of the style constants defined in
* class <code>SWT</code> which is applicable to instances of this
* class, or must be built by <em>bitwise OR</em>'ing together
* (that is, using the <code>int</code> "|" operator) two or more
* of those <code>SWT</code> style constants. The class description
* lists the style constants that are applicable to the class.
* Style bits are also inherited from superclasses.
* </p>
*
* @param parentItem a tree control which will be the parent of the new instance (cannot be null)
* @param style the style of control to construct
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_NULL_ARGUMENT - if the parent is null</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li>
* <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li>
* </ul>
*
* @see SWT
* @see Widget#checkSubclass
* @see Widget#getStyle
*/
public TreeItem (TreeItem parentItem, int style) {
this (parentItem, style, checkNull (parentItem).items.length);
}
/**
* Constructs a new instance of this class given its parent
* (which must be a <code>Tree</code> or a <code>TreeItem</code>),
* a style value describing its behavior and appearance, and the index
* at which to place it in the items maintained by its parent.
* <p>
* The style value is either one of the style constants defined in
* class <code>SWT</code> which is applicable to instances of this
* class, or must be built by <em>bitwise OR</em>'ing together
* (that is, using the <code>int</code> "|" operator) two or more
* of those <code>SWT</code> style constants. The class description
* lists the style constants that are applicable to the class.
* Style bits are also inherited from superclasses.
* </p>
*
* @param parentItem a tree control which will be the parent of the new instance (cannot be null)
* @param style the style of control to construct
* @param index the zero-relative index to store the receiver in its parent
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_NULL_ARGUMENT - if the parent is null</li>
* <li>ERROR_INVALID_RANGE - if the index is not between 0 and the number of elements in the parent (inclusive)</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li>
* <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li>
* </ul>
*
* @see SWT
* @see Widget#checkSubclass
* @see Widget#getStyle
*/
public TreeItem (TreeItem parentItem, int style, int index) {
this (parentItem, style, index, true);
}
TreeItem (TreeItem parentItem, int style, int index, boolean notifyParent) {
super (parentItem, style);
this.parentItem = parentItem;
parent = parentItem.parent;
depth = parentItem.depth + 1;
int validItemIndex = parentItem.items.length;
if (!(0 <= index && index <= validItemIndex)) error (SWT.ERROR_INVALID_RANGE);
int columnCount = parent.columns.length;
if (columnCount > 0) {
displayTexts = new String [columnCount];
if (columnCount > 1) {
texts = new String [columnCount];
textWidths = new int [columnCount];
images = new Image [columnCount];
}
}
if (notifyParent) parentItem.addItem (this, index);
}
TreeItem (Tree parent, int style, int index, boolean notifyParent) {
super (parent, style);
int validItemIndex = parent.items.length;
if (!(0 <= index && index <= validItemIndex)) error (SWT.ERROR_INVALID_RANGE);
this.parent = parent;
int columnCount = parent.columns.length;
if (columnCount > 0) {
displayTexts = new String [columnCount];
if (columnCount > 1) {
texts = new String [columnCount];
textWidths = new int [columnCount];
images = new Image [columnCount];
}
}
if (notifyParent) parent.createItem (this, index);
}
/*
* Updates internal structures in the receiver and its child items to handle the creation of a new column.
*/
void addColumn (TreeColumn column) {
int index = column.getIndex ();
int columnCount = parent.columns.length;
if (columnCount > 1) {
if (columnCount == 2) {
texts = new String [2];
} else {
String[] newTexts = new String [columnCount];
System.arraycopy (texts, 0, newTexts, 0, index);
System.arraycopy (texts, index, newTexts, index + 1, columnCount - index - 1);
texts = newTexts;
}
if (index == 0) {
texts [1] = text;
text = ""; //$NON-NLS-1$
}
if (columnCount == 2) {
images = new Image [2];
} else {
Image[] newImages = new Image [columnCount];
System.arraycopy (images, 0, newImages, 0, index);
System.arraycopy (images, index, newImages, index + 1, columnCount - index - 1);
images = newImages;
}
if (index == 0) {
images [1] = image;
image = null;
}
int[] newTextWidths = new int [columnCount];
System.arraycopy (textWidths, 0, newTextWidths, 0, index);
System.arraycopy (textWidths, index, newTextWidths, index + 1, columnCount - index - 1);
textWidths = newTextWidths;
} else {
customWidth = -1; /* columnCount == 1 */
}
/*
* The length of displayTexts always matches the parent's column count, unless this
* count is zero, in which case displayTexts is null.
*/
String[] newDisplayTexts = new String [columnCount];
if (columnCount > 1) {
System.arraycopy (displayTexts, 0, newDisplayTexts, 0, index);
System.arraycopy (displayTexts, index, newDisplayTexts, index + 1, columnCount - index - 1);
}
displayTexts = newDisplayTexts;
if (cellBackgrounds != null) {
Color[] newCellBackgrounds = new Color [columnCount];
System.arraycopy (cellBackgrounds, 0, newCellBackgrounds, 0, index);
System.arraycopy (cellBackgrounds, index, newCellBackgrounds, index + 1, columnCount - index - 1);
cellBackgrounds = newCellBackgrounds;
}
if (cellForegrounds != null) {
Color[] newCellForegrounds = new Color [columnCount];
System.arraycopy (cellForegrounds, 0, newCellForegrounds, 0, index);
System.arraycopy (cellForegrounds, index, newCellForegrounds, index + 1, columnCount - index - 1);
cellForegrounds = newCellForegrounds;
}
if (cellFonts != null) {
Font[] newCellFonts = new Font [columnCount];
System.arraycopy (cellFonts, 0, newCellFonts, 0, index);
System.arraycopy (cellFonts, index, newCellFonts, index + 1, columnCount - index - 1);
cellFonts = newCellFonts;
int[] newFontHeights = new int [columnCount];
System.arraycopy (fontHeights, 0, newFontHeights, 0, index);
System.arraycopy (fontHeights, index, newFontHeights, index + 1, columnCount - index - 1);
fontHeights = newFontHeights;
}
int orderedIndex = column.getOrderIndex ();
if (orderedIndex == 0 && columnCount > 1) {
/*
* The new second ordered column now has more space available to it than it did while
* it was the first ordered column since it no longer has to show hierarchy decorations,
* so recompute its displayText.
*/
TreeColumn[] orderedColumns = parent.getOrderedColumns ();
int secondColumnIndex = orderedColumns [1].getIndex ();
GC gc = new GC (parent);
gc.setFont (getFont (secondColumnIndex, false));
computeDisplayText (secondColumnIndex, gc);
gc.dispose ();
}
/* notify all child items as well */
for (int i = 0; i < items.length; i++) {
items[i].addColumn (column);
}
}
/*
* Adds a child item to the receiver.
*/
void addItem (TreeItem item, int index) {
TreeItem[] newChildren = new TreeItem [items.length + 1];
System.arraycopy (items, 0, newChildren, 0, index);
newChildren [index] = item;
System.arraycopy (items, index, newChildren, index + 1, items.length - index);
items = newChildren;
if (!item.isAvailable ()) {
/* receiver will now need an expander box if this is its first child */
if (isInViewport () && items.length == 1) {
Rectangle bounds = getExpanderBounds ();
parent.redraw (bounds.x, bounds.y, bounds.width, bounds.height, false);
}
return;
}
/* item should be available immediately so update parent */
parent.makeAvailable (item);
/* update scrollbars */
Rectangle bounds = item.getBounds (false);
int rightX = bounds.x + bounds.width;
parent.updateHorizontalBar (rightX, rightX);
parent.updateVerticalBar ();
/*
* If new item is above viewport then adjust topIndex and the vertical scrollbar
* so that the current viewport items will not change.
*/
if (item.availableIndex < parent.topIndex) {
parent.topIndex++;
ScrollBar vBar = parent.getVerticalBar ();
if (vBar != null) vBar.setSelection (parent.topIndex);
return;
}
parent.redrawFromItemDownwards (availableIndex);
}
static Tree checkNull (Tree tree) {
if (tree == null) SWT.error (SWT.ERROR_NULL_ARGUMENT);
return tree;
}
static TreeItem checkNull (TreeItem item) {
if (item == null) SWT.error (SWT.ERROR_NULL_ARGUMENT);
return item;
}
protected void checkSubclass () {
if (!isValidSubclass ()) error (SWT.ERROR_INVALID_SUBCLASS);
}
void clear () {
checked = grayed = false;
texts = null;
textWidths = new int [1];
fontHeight = 0;
fontHeights = null;
images = null;
foreground = background = null;
displayTexts = null;
cellForegrounds = cellBackgrounds = null;
font = null;
cellFonts = null;
cached = false;
text = "";
image = null;
int columnCount = parent.columns.length;
if (columnCount > 0) {
displayTexts = new String [columnCount];
if (columnCount > 1) {
texts = new String [columnCount];
textWidths = new int [columnCount];
images = new Image [columnCount];
}
}
}
/**
* Clears the item at the given zero-relative index in the receiver.
* The text, icon and other attributes of the item are set to the default
* value. If the tree was created with the <code>SWT.VIRTUAL</code> style,
* these attributes are requested again as needed.
*
* @param index the index of the item to clear
* @param all <code>true</code> if all child items of the indexed item should be
* cleared recursively, and <code>false</code> otherwise
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_INVALID_RANGE - if the index is not between 0 and the number of elements in the list minus 1 (inclusive)</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @see SWT#VIRTUAL
* @see SWT#SetData
*
* @since 3.2
*/
public void clear (int index, boolean recursive) {
checkWidget ();
if (!(0 <= index && index < items.length)) error (SWT.ERROR_INVALID_RANGE);
TreeItem item = items [index];
/* if there are no columns then the horizontal scrollbar may need adjusting */
TreeItem[] availableDescendents = null;
int oldRightX = 0;
if (item.availableIndex != -1 && parent.columns.length == 0) {
if (recursive) {
availableDescendents = item.computeAvailableDescendents ();
for (int i = 0; i < availableDescendents.length; i++) {
Rectangle bounds = availableDescendents [i].getBounds (false);
oldRightX = Math.max (oldRightX, bounds.x + bounds.width);
}
} else {
Rectangle bounds = item.getBounds (false);
oldRightX = bounds.x + bounds.width;
}
}
/* clear the item(s) */
item.clear ();
if (recursive) {
item.clearAll (true, false);
}
if (item.availableIndex == -1) return; /* no visual update needed */
/* adjust the horizontal scrollbar if needed */
if (parent.columns.length == 0) {
int newRightX = 0;
if (recursive) {
for (int i = 0; i < availableDescendents.length; i++) {
Rectangle bounds = availableDescendents [i].getBounds (false);
newRightX = Math.max (newRightX, bounds.x + bounds.width);
}
} else {
Rectangle bounds = item.getBounds (false);
newRightX = bounds.x + bounds.width;
}
parent.updateHorizontalBar (newRightX, newRightX - oldRightX);
}
/* redraw the item(s) */
if (recursive) {
int descendentCount = availableDescendents == null ?
item.computeAvailableDescendentCount () :
availableDescendents.length;
parent.redrawItems (item.availableIndex, item.availableIndex + descendentCount - 1, false);
} else {
parent.redrawItem (item.availableIndex, false);
}
}
/**
* Clears all the items in the receiver. The text, icon and other
* attributes of the items are set to their default values. If the
* tree was created with the <code>SWT.VIRTUAL</code> style, these
* attributes are requested again as needed.
*
* @param all <code>true</code> if all child items should be cleared
* recursively, and <code>false</code> otherwise
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @see SWT#VIRTUAL
* @see SWT#SetData
*
* @since 3.2
*/
public void clearAll (boolean recursive) {
clearAll (recursive, true);
}
void clearAll (boolean recursive, boolean doVisualUpdate) {
checkWidget ();
if (items.length == 0) return;
/* if there are no columns then the horizontal scrollbar may need adjusting */
TreeItem[] availableDescendents = null;
int oldRightX = 0;
if (doVisualUpdate && availableIndex != -1 && expanded && parent.columns.length == 0) {
if (recursive) {
availableDescendents = computeAvailableDescendents ();
/*
* i starts at 1 here because item 0 in availableDescendents
* will be the receiver, but this item is not being cleared.
*/
for (int i = 1; i < availableDescendents.length; i++) {
Rectangle bounds = availableDescendents [i].getBounds (false);
oldRightX = Math.max (oldRightX, bounds.x + bounds.width);
}
} else {
for (int i = 0; i < items.length; i++) {
Rectangle bounds = items [i].getBounds (false);
oldRightX = Math.max (oldRightX, bounds.x + bounds.width);
}
}
}
/* clear the item(s) */
for (int i = 0; i < items.length; i++) {
items [i].clear ();
if (recursive) items [i].clearAll (true, false);
}
if (!doVisualUpdate || availableIndex == -1 || !expanded) return; /* no visual update needed */
/* adjust the horizontal scrollbar if needed */
if (parent.columns.length == 0) {
int newRightX = 0;
if (recursive) {
/*
* i starts at 1 here because item 0 in availableDescendents
* is the receiver, but this item was not cleared.
*/
for (int i = 1; i < availableDescendents.length; i++) {
Rectangle bounds = availableDescendents [i].getBounds (false);
newRightX = Math.max (newRightX, bounds.x + bounds.width);
}
} else {
/*
* All cleared direct child items will have the same x and width
* values now, so just measure the first one as a sample.
*/
Rectangle bounds = items [0].getBounds (false);
newRightX = bounds.x + bounds.width;
}
parent.updateHorizontalBar (newRightX, newRightX - oldRightX);
}
/* redraw the item(s) */
if (recursive) {
int startIndex = items [0].availableIndex;
TreeItem lastChild = items [items.length - 1];
int endIndex = lastChild.availableIndex + lastChild.computeAvailableDescendentCount () - 1;
parent.redrawItems (startIndex, endIndex, false);
} else {
for (int i = 0; i < items.length; i++) {
parent.redrawItem (items [i].availableIndex, false);
}
}
}
/*
* Returns a collection of all tree items descending from the receiver, including
* the receiver. The order of the items in this collection are receiver, child0tree,
* child1tree, ..., childNtree.
*/
TreeItem[] computeAllDescendents () {
int childCount = items.length;
TreeItem[][] childResults = new TreeItem [childCount][];
int count = 1; /* receiver */
for (int i = 0; i < childCount; i++) {
childResults [i] = items [i].computeAllDescendents ();
count += childResults [i].length;
}
TreeItem[] result = new TreeItem [count];
int index = 0;
result [index++] = this;
for (int i = 0; i < childCount; i++) {
System.arraycopy (childResults [i], 0, result, index, childResults [i].length);
index += childResults [i].length;
}
return result;
}
/*
* Returns the number of tree items descending from the receiver, including the
* receiver, that are currently available. It is assumed that the receiver is
* currently available.
*/
int computeAvailableDescendentCount () {
int result = 1; /* receiver */
if (!expanded) return result;
for (int i = 0; i < items.length; i++) {
result += items [i].computeAvailableDescendentCount ();
}
return result;
}
/*
* Returns a collection of the tree items descending from the receiver, including
* the receiver, that are currently available. It is assumed that the receiver is
* currently available. The order of the items in this collection are receiver,
* child0tree, child1tree, ..., childNtree.
*/
TreeItem[] computeAvailableDescendents () {
if (!expanded) return new TreeItem[] {this};
int childCount = items.length;
TreeItem[][] childResults = new TreeItem [childCount][];
int count = 1; /* receiver */
for (int i = 0; i < childCount; i++) {
childResults [i] = items [i].computeAvailableDescendents ();
count += childResults [i].length;
}
TreeItem[] result = new TreeItem [count];
int index = 0;
result [index++] = this;
for (int i = 0; i < childCount; i++) {
System.arraycopy (childResults [i], 0, result, index, childResults [i].length);
index += childResults [i].length;
}
return result;
}
void computeDisplayText (int columnIndex, GC gc) {
if ((parent.style & SWT.VIRTUAL) != 0 && !cached) return; /* nothing to do */
int columnCount = parent.columns.length;
if (columnCount == 0) {
String text = getText (0, false);
textWidths [columnIndex] = gc.stringExtent (text).x;
return;
}
int orderedIndex = parent.columns.length == 0 ? 0 : parent.columns [columnIndex].getOrderIndex ();
TreeColumn column = parent.columns [columnIndex];
int availableWidth;
if (orderedIndex == 0) {
/* ordered column 0 is always LEFT and must consider hierarchy decorations */
availableWidth = column.getX () + column.width - getTextX (columnIndex) - 2 * MARGIN_TEXT;
} else {
/* ordered columns > 0 may not be LEFT so cannot use getTextX (int) */
availableWidth = column.width - 2 * parent.getCellPadding () - 2 * MARGIN_TEXT;
if (images [columnIndex] != null) {
availableWidth -= images [columnIndex].getBounds ().width;
availableWidth -= Tree.MARGIN_IMAGE;
}
}
String text = getText (columnIndex, false);
int textWidth = gc.stringExtent (text).x;
if (textWidth <= availableWidth) {
displayTexts [columnIndex] = text;
textWidths [columnIndex] = textWidth;
return;
}
/* Ellipsis will be needed, so subtract their width from the available text width */
int ellipsisWidth = gc.stringExtent (Tree.ELLIPSIS).x;
availableWidth -= ellipsisWidth;
if (availableWidth <= 0) {
displayTexts [columnIndex] = Tree.ELLIPSIS;
textWidths [columnIndex] = ellipsisWidth;
return;
}
/* Make initial guess. */
int index = Math.min (availableWidth / gc.getFontMetrics ().getAverageCharWidth (), text.length ());
textWidth = gc.stringExtent (text.substring (0, index)).x;
/* Initial guess is correct. */
if (availableWidth == textWidth) {
displayTexts [columnIndex] = text.substring (0, index) + Tree.ELLIPSIS;
textWidths [columnIndex] = textWidth + ellipsisWidth;
return;
}
/* Initial guess is too high, so reduce until fit is found. */
if (availableWidth < textWidth) {
do {
index--;
if (index < 0) {
displayTexts [columnIndex] = Tree.ELLIPSIS;
textWidths [columnIndex] = ellipsisWidth;
return;
}
text = text.substring (0, index);
textWidth = gc.stringExtent (text).x;
} while (availableWidth < textWidth);
displayTexts [columnIndex] = text + Tree.ELLIPSIS;
textWidths [columnIndex] = textWidth + ellipsisWidth;
return;
}
/* Initial guess is too low, so increase until overrun is found. */
int previousWidth = 0;
while (textWidth < availableWidth) {
index++;
previousWidth = textWidth;
textWidth = gc.stringExtent (text.substring (0, index)).x;
}
displayTexts [columnIndex] = text.substring (0, index - 1) + Tree.ELLIPSIS;
textWidths [columnIndex] = previousWidth + ellipsisWidth;
}
void computeDisplayTexts (GC gc) {
if ((parent.style & SWT.VIRTUAL) != 0 && !cached) return; /* nothing to do */
int columnCount = parent.columns.length;
if (columnCount == 0) return;
for (int i = 0; i < columnCount; i++) {
gc.setFont (getFont (i, false));
computeDisplayText (i, gc);
}
}
/*
* Computes the cached text widths.
*/
void computeTextWidths (GC gc) {
if ((parent.style & SWT.VIRTUAL) != 0 && !cached) return; /* nothing to do */
int validColumnCount = Math.max (1, parent.columns.length);
textWidths = new int [validColumnCount];
for (int i = 0; i < textWidths.length; i++) {
String value = getDisplayText (i);
if (value != null) {
gc.setFont (getFont (i, false));
textWidths [i] = gc.stringExtent (value).x;
}
}
}
public void dispose () {
if (isDisposed ()) return;
int startIndex = -1, endIndex = -1;
Tree parent = this.parent;
int index = getIndex ();
/* determine the indices, if any, that will need to be visually updated */
if (isAvailable ()) {
if (isLastChild () && index > 0) {
/* vertical connector lines no longer needed for this item */
if (parentItem != null) {
startIndex = parentItem.items [index - 1].availableIndex;
} else {
startIndex = parent.items [index - 1].availableIndex;
}
} else {
startIndex = availableIndex;
}
endIndex = parent.availableItemsCount - 1;
}
/* for performance do this upfront for whole descendent chain */
TreeItem focusItem = parent.focusItem;
if (focusItem != null && focusItem.hasAncestor (this)) {
parent.setFocusItem (this, false);
parent.reassignFocus ();
focusItem = parent.focusItem;
if (focusItem != null) {
parent.redrawItem (focusItem.availableIndex, true);
}
}
if (parentItem != null) parentItem.removeItem (this, index);
dispose (true);
if (startIndex != -1) {
parent.redrawItems (startIndex, endIndex, false);
}
}
void dispose (boolean notifyParent) {
if (isDisposed ()) return;
for (int i = 0; i < items.length; i++) {
items [i].dispose (notifyParent);
}
if (notifyParent) parent.destroyItem (this);
super.dispose (); /* super is intentional here */
background = foreground = null;
cellBackgrounds = cellForegrounds = null;
font = null;
cellFonts = null;
images = null;
texts = displayTexts = null;
textWidths = fontHeights = null;
parent = null;
parentItem = null;
items = null;
}
/*
* Ensure that all ancestors of the receiver are expanded
*/
void expandAncestors () {
if (parentItem != null) parentItem.expandAncestors ();
setExpanded (true);
Event newEvent = new Event ();
newEvent.item = this;
parent.inExpand = true;
parent.sendEvent (SWT.Expand, newEvent);
parent.inExpand = false;
if (isDisposed ()) return;
if (items.length == 0) {
expanded = false;
}
}
/**
* Returns the receiver's background color.
*
* @return the background color
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 2.0
*
*/
public Color getBackground () {
checkWidget ();
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
if (background != null) return background;
return parent.getBackground ();
}
/**
* Returns the background color at the given column index in the receiver.
*
* @param index the column index
* @return the background color
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public Color getBackground (int columnIndex) {
checkWidget ();
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
int validColumnCount = Math.max (1, parent.columns.length);
if (!(0 <= columnIndex && columnIndex < validColumnCount)) return getBackground ();
if (cellBackgrounds == null || cellBackgrounds [columnIndex] == null) return getBackground ();
return cellBackgrounds [columnIndex];
}
/**
* Returns a rectangle describing the size and location of the receiver's
* text relative to its parent.
*
* @return the bounding rectangle of the receiver's text
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public Rectangle getBounds () {
checkWidget ();
return getBounds (true);
}
Rectangle getBounds (boolean checkData) {
if (checkData && !parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
if (!isAvailable ()) return new Rectangle (0, 0, 0, 0);
TreeColumn[] orderedColumns = parent.getOrderedColumns ();
int orderedCol0Index = orderedColumns.length == 0 ? 0 : orderedColumns [0].getIndex ();
int x = getTextX (orderedCol0Index);
int width = textWidths [orderedCol0Index] + 2 * MARGIN_TEXT;
if (orderedColumns.length > 0) {
TreeColumn column = orderedColumns [0];
int right = column.getX () + column.width;
if (x + width > right) {
width = Math.max (0, right - x);
}
}
return new Rectangle (x, parent.getItemY (this), width, parent.itemHeight);
}
/**
* Returns a rectangle describing the receiver's size and location
* relative to its parent at a column in the tree.
*
* @param index the index that specifies the column
* @return the receiver's bounding column rectangle
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public Rectangle getBounds (int columnIndex) {
checkWidget ();
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
if (!isAvailable ()) return new Rectangle (0, 0, 0, 0);
TreeColumn[] columns = parent.columns;
int columnCount = columns.length;
int validColumnCount = Math.max (1, columnCount);
if (!(0 <= columnIndex && columnIndex < validColumnCount)) {
return new Rectangle (0, 0, 0, 0);
}
/*
* If there are no columns then this is the bounds of the receiver's content.
*/
if (columnCount == 0) {
return new Rectangle (
getContentX (0),
parent.getItemY (this),
getContentWidth (0),
parent.itemHeight - 1);
}
TreeColumn column = columns [columnIndex];
if (column.getOrderIndex () == 0) {
/*
* For ordered column 0 this is bounds from the beginning of the content to the
* end of the column.
*/
int x = getContentX (columnIndex);
int offset = x - column.getX ();
int width = Math.max (0, column.width - offset - 1); /* max is for columns with small widths */
return new Rectangle (x, parent.getItemY (this) + 1, width, parent.itemHeight - 1);
}
/*
* For ordered columns > 0 this is the bounds of the tree cell.
*/
return new Rectangle (column.getX (), parent.getItemY (this) + 1, column.width, parent.itemHeight - 1);
}
/*
* Returns the full bounds of a cell in a tree, regardless of its content.
*/
Rectangle getCellBounds (int columnIndex) {
int y = parent.getItemY (this);
if (parent.columns.length == 0) {
int width;
if (customWidth != -1) {
width = getContentX (0) + customWidth + parent.horizontalOffset;
} else {
int textPaintWidth = textWidths [0] + 2 * MARGIN_TEXT;
width = getTextX (0) + textPaintWidth + parent.horizontalOffset;
}
return new Rectangle (-parent.horizontalOffset, y, width, parent.itemHeight);
}
TreeColumn column = parent.columns [columnIndex];
return new Rectangle (column.getX (), y, column.width, parent.itemHeight);
}
/*
* Returns the bounds of the receiver's checkbox, or null if the parent's style does not
* include SWT.CHECK.
*/
Rectangle getCheckboxBounds () {
if ((parent.getStyle () & SWT.CHECK) == 0) return null;
int itemHeight = parent.itemHeight;
Rectangle result = parent.checkboxBounds;
Point[] hLinePoints = getHconnectorEndpoints ();
result.x = hLinePoints [1].x;
result.y = parent.getItemY (this) + (itemHeight - result.height) / 2;
return result;
}
/**
* Returns <code>true</code> if the receiver is checked,
* and false otherwise. When the parent does not have
* the <code>CHECK style, return false.
* <p>
*
* @return the checked state
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public boolean getChecked () {
checkWidget ();
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
return checked;
}
int getContentWidth (int columnIndex) {
int width = textWidths [columnIndex] + 2 * MARGIN_TEXT;
int orderedIndex = parent.columns.length == 0 ? 0 : parent.columns [columnIndex].getOrderIndex ();
if (orderedIndex == 0) {
width += parent.orderedCol0imageWidth;
if (parent.orderedCol0imageWidth > 0) width += Tree.MARGIN_IMAGE;
} else {
Image image = getImage (columnIndex, false);
if (image != null) {
width += image.getBounds ().width + Tree.MARGIN_IMAGE;
}
}
return width;
}
/*
* Returns the x value where the receiver's content (ie.- its image or text) begins
* for the specified column. For ordered columns > 0 this is dependent upon column
* alignment, and for ordered column 0 this is dependent upon the receiver's depth in
* the tree item hierarchy and the presence/absence of a checkbox.
*/
int getContentX (int columnIndex) {
int orderedIndex = parent.columns.length == 0 ? 0 : parent.columns [columnIndex].getOrderIndex ();
if (orderedIndex > 0) {
TreeColumn column = parent.columns [columnIndex];
int contentX = column.getX () + parent.getCellPadding ();
if ((column.style & SWT.LEFT) != 0) return contentX;
/* column is not left-aligned */
int contentWidth = getContentWidth (columnIndex);
if ((column.style & SWT.RIGHT) != 0) {
int padding = parent.getCellPadding ();
contentX = Math.max (contentX, column.getX () + column.width - padding - contentWidth);
} else { /* SWT.CENTER */
contentX = Math.max (contentX, column.getX () + (column.width - contentWidth) / 2);
}
return contentX;
}
/* ordered column 0 (always left-aligned) */
if ((parent.style & SWT.CHECK) != 0) {
Rectangle checkBounds = getCheckboxBounds ();
return checkBounds.x + checkBounds.width + Tree.MARGIN_IMAGE;
}
int contentX = parent.getCellPadding () - parent.horizontalOffset;
if (parentItem != null) {
int expanderWidth = parent.expanderBounds.width + INDENT_HIERARCHY;
contentX += expanderWidth * depth;
}
contentX += parent.expanderBounds.width;
return contentX + Tree.MARGIN_IMAGE + INDENT_HIERARCHY;
}
String getDisplayText (int columnIndex) {
if (parent.columns.length == 0) return getText (0, false);
String result = displayTexts [columnIndex];
return result != null ? result : ""; //$NON-NLS-1$
}
/**
* Returns <code>true</code> if the receiver is expanded,
* and false otherwise.
* <p>
*
* @return the expanded state
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public boolean getExpanded () {
checkWidget ();
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
return expanded;
}
/*
* Returns the bounds of the receiver's expander box, regardless of whether the
* receiver currently has children or not.
*/
Rectangle getExpanderBounds () {
int itemHeight = parent.itemHeight;
int x = parent.getCellPadding () - parent.horizontalOffset;
int y = parent.getItemY (this);
if (parentItem != null) {
int expanderWidth = parent.expanderBounds.width + INDENT_HIERARCHY;
x += expanderWidth * depth;
}
return new Rectangle (
x, y + (itemHeight - parent.expanderBounds.height) / 2,
parent.expanderBounds.width, parent.expanderBounds.height);
}
/*
* Returns the bounds that should be used for drawing a focus rectangle on the receiver
*/
Rectangle getFocusBounds () {
TreeColumn[] columns = parent.columns;
int orderedCol0index = columns.length == 0 ? 0 : parent.getOrderedColumns ()[0].getIndex ();
int x = getTextX (orderedCol0index);
int width;
if (columns.length > 0) {
/* ensure that the focus x does not start beyond the right bound of ordered column 0 */
int rightX = columns [orderedCol0index].getX () + columns [orderedCol0index].width;
x = Math.min (x, rightX - 1);
TreeColumn column;
if ((parent.style & SWT.FULL_SELECTION) != 0) {
int[] columnOrder = parent.getColumnOrder ();
column = columns [columnOrder [columnOrder.length - 1]]; /* last ordered column */
} else {
column = columns [orderedCol0index];
}
width = column.getX () + column.width - x - 1;
} else { /* no columns */
if (customWidth != -1) {
width = customWidth;
} else {
width = textWidths [0] + 2 * MARGIN_TEXT;
}
}
return new Rectangle (
x,
parent.getItemY (this) + (parent.linesVisible ? 1 : 0),
width,
parent.itemHeight - (parent.linesVisible ? 1 : 0));
}
/**
* Returns the font that the receiver will use to paint textual information for this item.
*
* @return the receiver's font
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.0
*/
public Font getFont () {
checkWidget ();
return getFont (true);
}
Font getFont (boolean checkData) {
if (checkData && !parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
if (font != null) return font;
return parent.getFont ();
}
/**
* Returns the font that the receiver will use to paint textual information
* for the specified cell in this item.
*
* @param index the column index
* @return the receiver's font
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public Font getFont (int columnIndex) {
checkWidget ();
return getFont (columnIndex, true);
}
Font getFont (int columnIndex, boolean checkData) {
if (checkData && !parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
int validColumnCount = Math.max (1, parent.columns.length);
if (!(0 <= columnIndex && columnIndex < validColumnCount)) return getFont (checkData);
if (cellFonts == null || cellFonts [columnIndex] == null) return getFont (checkData);
return cellFonts [columnIndex];
}
int getFontHeight () {
if (fontHeight != 0) return fontHeight;
return parent.fontHeight;
}
int getFontHeight (int columnIndex) {
if (fontHeights == null || fontHeights [columnIndex] == 0) return getFontHeight ();
return fontHeights [columnIndex];
}
/**
* Returns the foreground color that the receiver will use to draw.
*
* @return the receiver's foreground color
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 2.0
*
*/
public Color getForeground () {
checkWidget ();
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
if (foreground != null) return foreground;
return parent.getForeground ();
}
/**
*
* Returns the foreground color at the given column index in the receiver.
*
* @param index the column index
* @return the foreground color
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public Color getForeground (int columnIndex) {
checkWidget ();
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
int validColumnCount = Math.max (1, parent.columns.length);
if (!(0 <= columnIndex && columnIndex < validColumnCount)) return getForeground ();
if (cellForegrounds == null || cellForegrounds [columnIndex] == null) return getForeground ();
return cellForegrounds [columnIndex];
}
/**
* Returns <code>true</code> if the receiver is grayed,
* and false otherwise. When the parent does not have
* the <code>CHECK style, return false.
* <p>
*
* @return the grayed state of the checkbox
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public boolean getGrayed () {
checkWidget ();
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
return grayed;
}
/*
* Answers the start and end points of the horizontal connector line that is
* drawn between an item's expander box and its checkbox or content.
*/
Point[] getHconnectorEndpoints () {
Rectangle expanderBounds = getExpanderBounds ();
int x, width;
if (items.length == 0) { /* no child items, so no expander box */
x = expanderBounds.x + Compatibility.ceil (expanderBounds.width, 2);
width = Compatibility.floor (expanderBounds.width, 2) + INDENT_HIERARCHY;
} else { /* has child items */
x = expanderBounds.x + expanderBounds.width;
width = INDENT_HIERARCHY;
}
int y = expanderBounds.y + expanderBounds.height / 2;
return new Point[] {
new Point (x, y),
new Point (x + width, y)
};
}
/*
* Returns the bounds representing the clickable region that should select the receiver.
*/
Rectangle getHitBounds () {
int[] columnOrder = parent.getColumnOrder ();
int orderedCol0index = columnOrder.length == 0 ? 0 : parent.columns [columnOrder [0]].getIndex ();
int contentX = getContentX (orderedCol0index);
int width = 0;
TreeColumn[] columns = parent.columns;
if (columns.length == 0) {
width = getContentWidth (0);
} else {
/*
* If there are columns then this spans from the beginning of the receiver's column 0
* image or text to the end of either column 0 or the last column (FULL_SELECTION).
*/
TreeColumn column;
if ((parent.style & SWT.FULL_SELECTION) != 0) {
column = columns [columnOrder [columnOrder.length - 1]]; /* last column */
} else {
column = columns [orderedCol0index];
}
width = column.getX () + column.width - contentX;
}
return new Rectangle (contentX, parent.getItemY (this), width, parent.itemHeight);
}
public Image getImage () {
checkWidget ();
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
return super.getImage ();
}
/**
* Returns the image stored at the given column index in the receiver,
* or null if the image has not been set or if the column does not exist.
*
* @param index the column index
* @return the image stored at the given column index in the receiver
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public Image getImage (int columnIndex) {
checkWidget ();
return getImage (columnIndex, true);
}
Image getImage (int columnIndex, boolean checkData) {
if (checkData && !parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
int validColumnCount = Math.max (1, parent.columns.length);
if (!(0 <= columnIndex && columnIndex < validColumnCount)) return null;
if (columnIndex == 0) return super.getImage (); /* super is intentional here */
return images [columnIndex];
}
/**
* Returns a rectangle describing the size and location
* relative to its parent of an image at a column in the
* tree.
*
* @param index the index that specifies the column
* @return the receiver's bounding image rectangle
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public Rectangle getImageBounds (int columnIndex) {
checkWidget ();
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
int validColumnCount = Math.max (1, parent.columns.length);
if (!(0 <= columnIndex && columnIndex < validColumnCount)) return new Rectangle (0,0,0,0);
int padding = parent.getCellPadding ();
int startX = getContentX (columnIndex);
int itemHeight = parent.itemHeight;
int imageSpaceY = itemHeight - 2 * padding;
int y = parent.getItemY (this);
int orderedIndex = parent.columns.length == 0 ? 0 : parent.columns [columnIndex].getOrderIndex ();
Image image = getImage (columnIndex, false);
int drawWidth = 0;
if (orderedIndex == 0) {
/* for ordered column 0 all images have the same width */
drawWidth = parent.orderedCol0imageWidth;
} else {
if (image != null) drawWidth = image.getBounds ().width;
}
return new Rectangle (startX, y + padding, drawWidth, imageSpaceY);
}
int getIndex () {
TreeItem[] items;
if (parentItem != null) {
items = parentItem.items;
} else {
items = parent.items;
}
for (int i = 0; i < items.length; i++) {
if (items [i] == this) return i;
}
return -1;
}
/**
* Returns the item at the given, zero-relative index in the
* receiver. Throws an exception if the index is out of range.
*
* @param index the index of the item to return
* @return the item at the given index
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_INVALID_RANGE - if the index is not between 0 and the number of elements in the list minus 1 (inclusive)</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public TreeItem getItem (int index) {
checkWidget ();
if (index < 0) error (SWT.ERROR_INVALID_RANGE);
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
if (index >= items.length) error (SWT.ERROR_INVALID_RANGE);
return items [index];
}
/**
* Returns the number of items contained in the receiver
* that are direct item children of the receiver.
*
* @return the number of items
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public int getItemCount () {
checkWidget ();
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
return items.length;
}
String getNameText () {
if ((parent.style & SWT.VIRTUAL) != 0) {
if (!cached) return "*virtual*"; //$NON-NLS-1$
}
return super.getNameText ();
}
/**
* Returns a (possibly empty) array of <code>TreeItem</code>s which
* are the direct item children of the receiver.
* <p>
* Note: This is not the actual structure used by the receiver
* to maintain its list of items, so modifying the array will
* not affect the receiver.
* </p>
*
* @return the receiver's items
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public TreeItem [] getItems () {
checkWidget ();
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
TreeItem[] result = new TreeItem [items.length];
System.arraycopy (items, 0, result, 0, items.length);
return result;
}
/**
* Returns the receiver's parent, which must be a <code>Tree</code>.
*
* @return the receiver's parent
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public Tree getParent () {
checkWidget ();
return parent;
}
/**
* Returns the receiver's parent item, which must be a
* <code>TreeItem</code> or null when the receiver is a
* root.
*
* @return the receiver's parent item
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public TreeItem getParentItem () {
checkWidget ();
return parentItem;
}
/*
* Returns the receiver's ideal width for the specified columnIndex.
*/
int getPreferredWidth (int columnIndex) {
int width = 0;
GC gc = new GC (parent);
gc.setFont (getFont (columnIndex, false));
width += gc.stringExtent (getText (columnIndex, false)).x + 2 * MARGIN_TEXT;
int orderedIndex = parent.columns.length == 0 ? 0 : parent.columns [columnIndex].getOrderIndex ();
if (orderedIndex == 0) {
if (parent.orderedCol0imageWidth > 0) {
width += parent.orderedCol0imageWidth;
width += Tree.MARGIN_IMAGE;
}
} else {
Image image = getImage (columnIndex, false);
if (image != null) {
width += image.getBounds ().width;
width += Tree.MARGIN_IMAGE;
}
}
if (parent.hooks (SWT.MeasureItem)) {
Event event = new Event ();
event.item = this;
event.gc = gc;
event.index = columnIndex;
event.x = getContentX (columnIndex);
event.y = parent.getItemY (this);
event.width = width;
event.height = parent.itemHeight;
event.detail = isSelected () ? SWT.SELECTED : 0;
parent.sendEvent (SWT.MeasureItem, event);
if (parent.itemHeight != event.height) {
parent.customHeightSet = true;
boolean update = parent.setItemHeight (event.height + 2 * parent.getCellPadding ());
if (update) parent.redraw ();
}
width = event.width;
}
gc.dispose ();
if (orderedIndex == 0) {
return getContentX (columnIndex) + parent.horizontalOffset + width + parent.getCellPadding (); /* right side cell pad */
}
return width + 2 * parent.getCellPadding ();
}
public String getText () {
checkWidget ();
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
return super.getText ();
}
/**
* Returns the text stored at the given column index in the receiver,
* or empty string if the text has not been set.
*
* @param index the column index
* @return the text stored at the given column index in the receiver
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public String getText (int columnIndex) {
checkWidget ();
return getText (columnIndex, true);
}
String getText (int columnIndex, boolean checkData) {
if (checkData && !parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
int validColumnCount = Math.max (1, parent.columns.length);
if (!(0 <= columnIndex && columnIndex < validColumnCount)) return ""; //$NON-NLS-1$
if (columnIndex == 0) return super.getText (); /* super is intentional here */
if (texts [columnIndex] == null) return ""; //$NON-NLS-1$
return texts [columnIndex];
}
/**
* Returns a rectangle describing the size and location
* relative to its parent of the text at a column in the
* tree.
*
* @param index the index that specifies the column
* @return the receiver's bounding text rectangle
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.3
*/
public Rectangle getTextBounds (int columnIndex) {
checkWidget ();
if (!parent.checkData (this, true)) error (SWT.ERROR_WIDGET_DISPOSED);
if (!isAvailable ()) return new Rectangle (0, 0, 0, 0);
TreeColumn[] columns = parent.columns;
int columnCount = columns.length;
int validColumnCount = Math.max (1, columnCount);
if (!(0 <= columnIndex && columnIndex < validColumnCount)) {
return new Rectangle (0, 0, 0, 0);
}
/*
* If there are no columns then this is the bounds of the receiver's content.
*/
if (columnCount == 0) {
int x = getTextX (0) + MARGIN_TEXT;
int width = Math.max (0, getContentX(0) + getContentWidth (0) - x);
return new Rectangle (
x,
parent.getItemY (this),
width,
parent.itemHeight - 1);
}
TreeColumn column = columns [columnIndex];
if (column.getOrderIndex () == 0) {
/*
* For ordered column 0 this is bounds from the beginning of the content to the
* end of the column.
*/
int x = getTextX (columnIndex) + MARGIN_TEXT;
int offset = x - column.getX ();
int width = Math.max (0, column.width - offset - 1); /* max is for columns with small widths */
return new Rectangle (x, parent.getItemY (this) + 1, width, parent.itemHeight - 1);
}
/*
* For ordered columns > 0 this is the bounds of the tree cell.
*/
int x = getTextX (columnIndex) + MARGIN_TEXT;
int offset = x - column.getX ();
int width = Math.max (0, column.width - offset - MARGIN_TEXT);
return new Rectangle (x, parent.getItemY (this) + 1, width, parent.itemHeight - 1);
}
/*
* Returns the x value where the receiver's text begins.
*/
int getTextX (int columnIndex) {
int orderedIndex = parent.columns.length == 0 ? 0 : parent.columns [columnIndex].getOrderIndex ();
int textX = getContentX (columnIndex);
if (orderedIndex == 0) {
textX += parent.orderedCol0imageWidth;
if (parent.orderedCol0imageWidth > 0) textX += Tree.MARGIN_IMAGE;
} else {
Image image = getImage (columnIndex, false);
if (image != null) {
textX += image.getBounds ().width + Tree.MARGIN_IMAGE;
}
}
return textX;
}
/*
* Returns true if the receiver descends from (or is identical to) the item.
*/
boolean hasAncestor (TreeItem item) {
if (this == item) return true;
if (parentItem == null) return false;
return parentItem.hasAncestor (item);
}
/**
* Searches the receiver's list starting at the first item
* (index 0) until an item is found that is equal to the
* argument, and returns the index of that item. If no item
* is found, returns -1.
*
* @param item the search item
* @return the index of the item
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_NULL_ARGUMENT - if the item is null</li>
* <li>ERROR_INVALID_ARGUMENT - if the item has been disposed</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public int indexOf (TreeItem item) {
checkWidget ();
if (item == null) error (SWT.ERROR_NULL_ARGUMENT);
if (item.isDisposed ()) error (SWT.ERROR_INVALID_ARGUMENT);
if (item.parentItem != this) return -1;
return item.getIndex ();
}
/*
* Returns true if the receiver is currently available (though not necessary in the viewport).
*/
boolean isAvailable () {
if (parentItem == null) return true; /* root items are always available */
if (!parentItem.expanded) return false;
return parentItem.isAvailable ();
}
/*
* Answers a boolean indicating whether the receiver's y is within the current
* viewport of the parent.
*/
boolean isInViewport () {
if (availableIndex == -1) return false;
int topIndex = parent.topIndex;
if (availableIndex < topIndex) return false;
int visibleCount = parent.clientArea.height / parent.itemHeight;
return availableIndex <= topIndex + visibleCount;
}
/*
* Returns true if the receiver is the last child of its parent item, or of its parent
* if the receiver is a root item, and false otherwise.
*/
boolean isLastChild () {
if (parentItem != null) {
return getIndex () == parentItem.items.length - 1;
}
return getIndex () == parent.items.length - 1;
}
boolean isSelected () {
return parent.getSelectionIndex (this) != -1;
}
/*
* The backgroundOnly argument indicates whether the item should only
* worry about painting its background color and selection.
*
* Returns a boolean indicating whether to abort drawing focus on the item.
* If the receiver is not the current focus item then this value is irrelevant.
*/
boolean paint (GC gc, TreeColumn column, boolean backgroundOnly) {
if (!parent.checkData (this, true)) return false;
int columnIndex = 0, orderedIndex = 0, x = 0;
if (column != null) {
columnIndex = column.getIndex ();
orderedIndex = column.getOrderIndex ();
x = column.getX ();
}
/*
* Capture GC attributes that will need to be restored later in the paint
* process to ensure that the item paints as intended without being affected
* by GC changes made in MeasureItem/EraseItem/PaintItem callbacks.
*/
int oldAlpha = gc.getAlpha ();
boolean oldAdvanced = gc.getAdvanced ();
int oldAntialias = gc.getAntialias ();
Pattern oldBackgroundPattern = gc.getBackgroundPattern ();
Pattern oldForegroundPattern = gc.getForegroundPattern ();
int oldInterpolation = gc.getInterpolation ();
int[] oldLineDash = gc.getLineDash ();
int oldLineWidth = gc.getLineWidth ();
int oldTextAntialias = gc.getTextAntialias ();
boolean isSelected = isSelected ();
if (parent.hooks (SWT.MeasureItem)) {
int contentWidth = getContentWidth (columnIndex);
int contentX = getContentX (columnIndex);
gc.setFont (getFont (columnIndex, false));
Event event = new Event ();
event.item = this;
event.gc = gc;
event.index = columnIndex;
event.x = contentX;
event.y = parent.getItemY (this);
event.width = contentWidth;
event.height = parent.itemHeight;
event.detail = isSelected ? SWT.SELECTED : 0;
parent.sendEvent (SWT.MeasureItem, event);
event.gc = null;
if (gc.isDisposed ()) return false;
gc.setAlpha (oldAlpha);
gc.setAntialias (oldAntialias);
gc.setBackgroundPattern (oldBackgroundPattern);
gc.setForegroundPattern (oldForegroundPattern);
gc.setInterpolation (oldInterpolation);
gc.setLineDash (oldLineDash);
gc.setLineWidth (oldLineWidth);
gc.setTextAntialias (oldTextAntialias);
gc.setAdvanced (oldAdvanced);
if (isDisposed ()) return false;
if (parent.itemHeight != event.height) {
parent.customHeightSet = true;
boolean update = parent.setItemHeight (event.height + 2 * parent.getCellPadding ());
if (update) parent.redraw ();
}
if (parent.columns.length == 0) {
int change = event.width - (customWidth != -1 ? customWidth : contentWidth);
if (event.width != contentWidth || customWidth != -1) customWidth = event.width;
if (change != 0) { /* scrollbar may be affected since no columns */
parent.updateHorizontalBar (contentX + event.width, change);
// TODO what if clip is too small now?
}
}
}
/* if this cell is completely to the right of the client area then there's no need to paint it */
Rectangle clientArea = parent.clientArea;
if (clientArea.x + clientArea.width < x) return false;
Rectangle cellBounds = getCellBounds (columnIndex);
if (parent.linesVisible) {
cellBounds.y++;
cellBounds.height--;
}
int cellRightX = 0;
if (column != null) {
cellRightX = column.getX () + column.width;
} else {
cellRightX = cellBounds.x + cellBounds.width;
}
/* restrict the clipping region to the cell */
gc.setClipping (x, cellBounds.y, clientArea.width - x, cellBounds.height);
int y = parent.getItemY (this);
int itemHeight = parent.itemHeight;
/* draw the parent background color/image of this cell */
if (column == null) {
parent.drawBackground (gc, 0, y, clientArea.width, itemHeight, 0, 0);
} else {
int fillWidth = cellBounds.width;
if (parent.linesVisible) fillWidth--;
parent.drawBackground (gc, cellBounds.x, cellBounds.y, fillWidth, cellBounds.height, 0, 0);
}
boolean isFocusItem = parent.focusItem == this && parent.isFocusControl ();
boolean drawBackground = true;
boolean drawForeground = true;
boolean drawSelection = isSelected;
boolean drawFocus = isFocusItem;
if (parent.hooks (SWT.EraseItem)) {
drawBackground = background != null || (cellBackgrounds != null && cellBackgrounds [columnIndex] != null);
gc.setFont (getFont (columnIndex, false));
if (isSelected && (columnIndex == 0 || (parent.style & SWT.FULL_SELECTION) != 0)) {
gc.setForeground (display.getSystemColor (SWT.COLOR_LIST_SELECTION_TEXT));
gc.setBackground (display.getSystemColor (SWT.COLOR_LIST_SELECTION));
} else {
gc.setForeground (getForeground (columnIndex));
gc.setBackground (getBackground (columnIndex));
}
Event event = new Event ();
event.item = this;
event.gc = gc;
event.index = columnIndex;
event.doit = true;
event.detail = SWT.FOREGROUND;
if (drawBackground) event.detail |= SWT.BACKGROUND;
if (isSelected) event.detail |= SWT.SELECTED;
if (isFocusItem) event.detail |= SWT.FOCUSED;
event.x = cellBounds.x;
event.y = cellBounds.y;
event.width = cellBounds.width;
event.height = cellBounds.height;
gc.setClipping (cellBounds);
parent.sendEvent (SWT.EraseItem, event);
event.gc = null;
if (gc.isDisposed ()) return false;
gc.setAlpha (oldAlpha);
gc.setAntialias (oldAntialias);
gc.setBackgroundPattern (oldBackgroundPattern);
gc.setClipping (cellBounds);
gc.setForegroundPattern (oldForegroundPattern);
gc.setInterpolation (oldInterpolation);
gc.setLineDash (oldLineDash);
gc.setLineWidth (oldLineWidth);
gc.setTextAntialias (oldTextAntialias);
gc.setAdvanced (oldAdvanced);
if (isDisposed ()) return false;
if (!event.doit) {
drawBackground = drawForeground = drawSelection = drawFocus = false;
} else {
drawBackground = drawBackground && (event.detail & SWT.BACKGROUND) != 0;
drawForeground = (event.detail & SWT.FOREGROUND) != 0;
drawSelection = isSelected && (event.detail & SWT.SELECTED) != 0;
drawFocus = isFocusItem && (event.detail & SWT.FOCUSED) != 0;
}
}
/* draw the cell's set background if appropriate */
if (drawBackground) {
gc.setBackground (getBackground (columnIndex));
if (columnIndex == 0 && (column == null || column.getOrderIndex () == 0)) {
Rectangle focusBounds = getFocusBounds ();
int fillWidth = 0;
if (column == null) {
fillWidth = focusBounds.width;
} else {
fillWidth = column.width - focusBounds.x;
if (parent.linesVisible) fillWidth--;
}
gc.fillRectangle (focusBounds.x, focusBounds.y, fillWidth, focusBounds.height);
} else {
int fillWidth = cellBounds.width;
gc.fillRectangle (cellBounds.x, cellBounds.y, fillWidth, cellBounds.height);
}
}
/* draw the selection bar if the receiver is selected */
if (drawSelection && isSelected && (orderedIndex == 0 || (parent.style & SWT.FULL_SELECTION) != 0)) {
gc.setBackground (display.getSystemColor (SWT.COLOR_LIST_SELECTION));
if (orderedIndex == 0) {
Rectangle focusBounds = getFocusBounds ();
int fillWidth = focusBounds.width;
if (parent.columns.length < 2 || (parent.style & SWT.FULL_SELECTION) == 0) {
fillWidth -= 2; /* space for right bound of focus rect */
}
if (fillWidth > 0) {
gc.fillRectangle (focusBounds.x + 1, focusBounds.y + 1, fillWidth, focusBounds.height - 2);
}
} else {
int fillWidth = column.width;
int[] columnOrder = parent.getColumnOrder ();
if (columnIndex == columnOrder [columnOrder.length - 1]) {
fillWidth -= 2; /* space for right bound of focus rect */
}
if (fillWidth > 0) {
gc.fillRectangle (
column.getX (),
cellBounds.y + 1,
fillWidth,
cellBounds.height - 2);
}
}
}
if (backgroundOnly) return false;
/* Draw column 0 decorations */
if (orderedIndex == 0) {
gc.setClipping (cellBounds);
/* Draw hierarchy connector lines */
Rectangle expanderBounds = getExpanderBounds ();
Color oldForeground = gc.getForeground ();
gc.setForeground (parent.getConnectorColor ());
/* Draw vertical line above expander */
int lineX = expanderBounds.x + expanderBounds.width / 2;
int y2 = expanderBounds.y;
if (items.length == 0) {
y2 += expanderBounds.height / 2;
}
/* Do not draw this line iff this is the very first item in the tree */
if (parentItem != null || getIndex () != 0) {
gc.drawLine (lineX, y, lineX, y2);
}
/* Draw vertical line below expander if the receiver has lower siblings */
if (!isLastChild ()) {
if (items.length != 0) y2 += expanderBounds.height;
gc.drawLine (lineX, y2, lineX, y + itemHeight);
}
/* Draw horizontal line to right of expander */
Point[] endpoints = getHconnectorEndpoints ();
gc.drawLine (endpoints [0].x, endpoints [0].y, endpoints [1].x - Tree.MARGIN_IMAGE, endpoints [1].y);
/*
* Draw hierarchy lines that are needed by other items that are shown below
* this item but whose parents are shown above (ie.- lines to the left of
* this item's connector line).
*/
TreeItem item = parentItem;
while (item != null) {
if (!item.isLastChild ()) {
Rectangle itemExpanderBounds = item.getExpanderBounds ();
lineX = itemExpanderBounds.x + itemExpanderBounds.width / 2;
gc.drawLine (lineX, y, lineX, y + itemHeight);
}
item = item.parentItem;
}
gc.setForeground (oldForeground);
/* Draw expand/collapse image if receiver has children */
if (items.length > 0) {
Image image = expanded ? parent.getExpandedImage () : parent.getCollapsedImage ();
gc.drawImage (image, expanderBounds.x, expanderBounds.y);
}
/* Draw checkbox if parent Tree has style SWT.CHECK */
if ((parent.style & SWT.CHECK) != 0) {
Image baseImage = grayed ? parent.getGrayUncheckedImage () : parent.getUncheckedImage ();
Rectangle checkboxBounds = getCheckboxBounds ();
gc.drawImage (baseImage, checkboxBounds.x, checkboxBounds.y);
/* Draw checkmark if item is checked */
if (checked) {
Image checkmarkImage = parent.getCheckmarkImage ();
Rectangle checkmarkBounds = checkmarkImage.getBounds ();
int xInset = (checkboxBounds.width - checkmarkBounds.width) / 2;
int yInset = (checkboxBounds.height - checkmarkBounds.height) / 2;
gc.drawImage (checkmarkImage, checkboxBounds.x + xInset, checkboxBounds.y + yInset);
}
}
}
if (drawForeground) {
Image image = getImage (columnIndex, false);
String text = getDisplayText (columnIndex);
Rectangle imageArea = getImageBounds (columnIndex);
int startX = imageArea.x;
/* while painting the cell's content restrict the clipping region */
int padding = parent.getCellPadding ();
gc.setClipping (
startX,
cellBounds.y + padding - (parent.linesVisible ? 1 : 0),
cellRightX - startX - padding,
cellBounds.height - 2 * (padding - (parent.linesVisible ? 1 : 0)));
/* draw the image */
if (image != null) {
Rectangle imageBounds = image.getBounds ();
gc.drawImage (
image,
0, 0, /* source x, y */
imageBounds.width, imageBounds.height, /* source width, height */
imageArea.x, imageArea.y, /* dest x, y */
imageArea.width, imageArea.height); /* dest width, height */
}
/* draw the text */
if (text.length () > 0) {
gc.setFont (getFont (columnIndex, false));
int fontHeight = getFontHeight (columnIndex);
if (drawSelection && (orderedIndex == 0 || (parent.style & SWT.FULL_SELECTION) != 0)) {
gc.setForeground (display.getSystemColor (SWT.COLOR_LIST_SELECTION_TEXT));
} else {
if (!isSelected || drawSelection) {
gc.setForeground (getForeground (columnIndex));
}
}
x = getTextX (columnIndex) + MARGIN_TEXT;
gc.drawString (text, x, y + (itemHeight - fontHeight) / 2, true);
}
}
if (parent.hooks (SWT.PaintItem)) {
int contentWidth = getContentWidth (columnIndex);
int contentX = getContentX (columnIndex);
gc.setFont (getFont (columnIndex, false));
if (isSelected && (columnIndex == 0 || (parent.style & SWT.FULL_SELECTION) != 0)) {
gc.setForeground (display.getSystemColor (SWT.COLOR_LIST_SELECTION_TEXT));
gc.setBackground (display.getSystemColor (SWT.COLOR_LIST_SELECTION));
} else {
gc.setForeground (getForeground (columnIndex));
gc.setBackground (getBackground (columnIndex));
}
Event event = new Event ();
event.item = this;
event.gc = gc;
event.index = columnIndex;
if (isSelected) event.detail |= SWT.SELECTED;
if (drawFocus) event.detail |= SWT.FOCUSED;
event.x = contentX;
event.y = cellBounds.y;
event.width = contentWidth;
event.height = cellBounds.height;
gc.setClipping (cellBounds);
parent.sendEvent (SWT.PaintItem, event);
event.gc = null;
if (gc.isDisposed ()) return false;
gc.setAlpha (oldAlpha);
gc.setAntialias (oldAntialias);
gc.setBackgroundPattern (oldBackgroundPattern);
gc.setClipping (cellBounds);
gc.setForegroundPattern (oldForegroundPattern);
gc.setInterpolation (oldInterpolation);
gc.setLineDash (oldLineDash);
gc.setLineWidth (oldLineWidth);
gc.setTextAntialias (oldTextAntialias);
gc.setAdvanced (oldAdvanced);
drawFocus = isFocusItem && (event.detail & SWT.FOCUSED) != 0;
}
return isFocusItem && !drawFocus;
}
/*
* Redraw part of the receiver. If either EraseItem or PaintItem is hooked then
* only full cells should be damaged, so adjust accordingly. If neither of these
* events are hooked then the exact bounds given for damaging can be used.
*/
void redraw (int x, int y, int width, int height, int columnIndex) {
if (!parent.hooks (SWT.EraseItem) && !parent.hooks (SWT.PaintItem)) {
parent.redraw (x, y, width, height, false);
return;
}
Rectangle cellBounds = getCellBounds (columnIndex);
parent.redraw (cellBounds.x, cellBounds.y, cellBounds.width, cellBounds.height, false);
}
void redrawItem () {
if (!isAvailable ()) return;
parent.redraw (0, parent.getItemY (this), parent.clientArea.width, parent.itemHeight, false);
}
/*
* Updates internal structures in the receiver and its child items to handle the removal of a column.
*/
void removeColumn (TreeColumn column, int index, int orderedIndex) {
int columnCount = parent.columns.length;
if (columnCount == 0) {
/* reverts to normal tree when last column disposed */
cellBackgrounds = cellForegrounds = null;
displayTexts = null;
cellFonts = null;
fontHeights = null;
GC gc = new GC (parent);
computeTextWidths (gc);
gc.dispose ();
/* notify all child items as well */
for (int i = 0; i < items.length; i++) {
items [i].removeColumn (column, index, orderedIndex);
}
return;
}
String[] newTexts = new String [columnCount];
System.arraycopy (texts, 0, newTexts, 0, index);
System.arraycopy (texts, index + 1, newTexts, index, columnCount - index);
texts = newTexts;
Image[] newImages = new Image [columnCount];
System.arraycopy (images, 0, newImages, 0, index);
System.arraycopy (images, index + 1, newImages, index, columnCount - index);
images = newImages;
int[] newTextWidths = new int [columnCount];
System.arraycopy (textWidths, 0, newTextWidths, 0, index);
System.arraycopy (textWidths, index + 1, newTextWidths, index, columnCount - index);
textWidths = newTextWidths;
String[] newDisplayTexts = new String [columnCount];
System.arraycopy (displayTexts, 0, newDisplayTexts, 0, index);
System.arraycopy (displayTexts, index + 1, newDisplayTexts, index, columnCount - index);
displayTexts = newDisplayTexts;
if (cellBackgrounds != null) {
Color[] newCellBackgrounds = new Color [columnCount];
System.arraycopy (cellBackgrounds, 0, newCellBackgrounds, 0, index);
System.arraycopy (cellBackgrounds, index + 1, newCellBackgrounds, index, columnCount - index);
cellBackgrounds = newCellBackgrounds;
}
if (cellForegrounds != null) {
Color[] newCellForegrounds = new Color [columnCount];
System.arraycopy (cellForegrounds, 0, newCellForegrounds, 0, index);
System.arraycopy (cellForegrounds, index + 1, newCellForegrounds, index, columnCount - index);
cellForegrounds = newCellForegrounds;
}
if (cellFonts != null) {
Font[] newCellFonts = new Font [columnCount];
System.arraycopy (cellFonts, 0, newCellFonts, 0, index);
System.arraycopy (cellFonts, index + 1, newCellFonts, index, columnCount - index);
cellFonts = newCellFonts;
int[] newFontHeights = new int [columnCount];
System.arraycopy (fontHeights, 0, newFontHeights, 0, index);
System.arraycopy (fontHeights, index + 1, newFontHeights, index, columnCount - index);
fontHeights = newFontHeights;
}
if (index == 0) {
text = texts [0] != null ? texts [0] : ""; //$NON-NLS-1$
texts [0] = null;
image = images [0];
images [0] = null;
}
if (orderedIndex == 0) {
/*
* The new first ordered column will not have as much width available to it as it did when
* it was the second ordered column since it now has to show hierarchy decorations as well,
* so recompute its displayText.
*/
int firstColumnIndex = parent.getOrderedColumns () [0].getIndex ();
GC gc = new GC (parent);
gc.setFont (getFont (firstColumnIndex, false));
computeDisplayText (firstColumnIndex, gc);
gc.dispose ();
}
if (columnCount < 2) {
texts = null;
images = null;
}
/* notify all child items as well */
for (int i = 0; i < items.length; i++) {
items [i].removeColumn (column, index, orderedIndex);
}
}
/**
* Removes all of the items from the receiver.
* <p>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public void removeAll () {
checkWidget ();
if (items.length == 0) return;
int lastAvailableIndex = parent.availableItemsCount - 1;
/* for performance do this upfront for whole descendent chain */
TreeItem focusItem = parent.focusItem;
if (focusItem != null && focusItem.hasAncestor (this)) {
parent.setFocusItem (this, false);
}
while (items.length > 0) {
items [0].dispose (true);
removeItem (items [0], 0);
}
items = Tree.NO_ITEMS;
expanded = false;
if (isAvailable ()) {
parent.redrawItems (availableIndex, lastAvailableIndex, false);
}
}
/*
* Removes a child item from the receiver.
*/
void removeItem (TreeItem item, int index) {
if (isDisposed ()) return;
TreeItem[] newItems = new TreeItem [items.length - 1];
System.arraycopy (items, 0, newItems, 0, index);
System.arraycopy (items, index + 1, newItems, index, newItems.length - index);
items = newItems;
if (items.length == 0) {
items = Tree.NO_ITEMS;
/* condition below handles creation of item within Expand callback */
if (!parent.inExpand) {
expanded = false;
if (isInViewport ()) {
Rectangle bounds = getExpanderBounds (); /* expander box no longer needed */
parent.redraw (bounds.x, bounds.y, bounds.width, bounds.height, false);
}
}
return;
}
}
/**
* Sets the receiver's background color to the color specified
* by the argument, or to the default system color for the item
* if the argument is null.
*
* @param color the new color (or null)
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 2.0
*
*/
public void setBackground (Color color) {
checkWidget ();
if (color != null && color.isDisposed ()) {
SWT.error (SWT.ERROR_INVALID_ARGUMENT);
}
Color oldColor = background;
if (oldColor == color) return;
background = color;
if (oldColor != null && oldColor.equals (color)) return;
if ((parent.style & SWT.VIRTUAL) != 0) cached = true;
redrawItem ();
}
/**
* Sets the background color at the given column index in the receiver
* to the color specified by the argument, or to the default system color for the item
* if the argument is null.
*
* @param index the column index
* @param color the new color (or null)
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*
*/
public void setBackground (int columnIndex, Color color) {
checkWidget ();
if (color != null && color.isDisposed ()) {
SWT.error (SWT.ERROR_INVALID_ARGUMENT);
}
int validColumnCount = Math.max (1, parent.columns.length);
if (!(0 <= columnIndex && columnIndex < validColumnCount)) return;
if (cellBackgrounds == null) {
if (color == null) return;
cellBackgrounds = new Color [validColumnCount];
}
Color oldColor = cellBackgrounds [columnIndex];
if (oldColor == color) return;
cellBackgrounds [columnIndex] = color;
if (oldColor != null && oldColor.equals (color)) return;
if ((parent.style & SWT.VIRTUAL) != 0) cached = true;
if (isInViewport ()) {
Rectangle bounds = getCellBounds (columnIndex);
parent.redraw (bounds.x, bounds.y, bounds.width, bounds.height, false);
}
}
/**
* Sets the checked state of the receiver.
* <p>
*
* @param checked the new checked state
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public void setChecked (boolean value) {
checkWidget ();
if ((parent.getStyle () & SWT.CHECK) == 0) return;
if (checked == value) return;
checked = value;
if ((parent.style & SWT.VIRTUAL) != 0) cached = true;
if (isInViewport ()) {
if (parent.hooks (SWT.EraseItem) || parent.hooks (SWT.PaintItem)) {
redrawItem ();
} else {
Rectangle bounds = getCheckboxBounds ();
parent.redraw (bounds.x, bounds.y, bounds.width, bounds.height, false);
}
}
}
/**
* Sets the expanded state of the receiver.
* <p>
*
* @param expanded the new expanded state
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public void setExpanded (boolean value) {
checkWidget ();
if (expanded == value) return;
if (items.length == 0) return;
if (parent.inExpand) return;
if ((parent.style & SWT.VIRTUAL) != 0) cached = true;
if (value) {
expanded = value;
if (availableIndex == -1) return;
TreeItem[] availableDescendents = computeAvailableDescendents ();
int descendentsCount = availableDescendents.length;
if (availableIndex != parent.availableItemsCount - 1) {
/* the receiver is not the last available item */
Rectangle clientArea = parent.clientArea;
int y = parent.getItemY (this) + parent.itemHeight;
if (0 < y && y < clientArea.height) {
if (parent.drawCount <= 0) {
parent.update ();
GC gc = new GC (parent);
gc.copyArea (
0, y,
clientArea.width, clientArea.height - y,
0, y + ((descendentsCount - 1) * parent.itemHeight));
gc.dispose ();
}
}
}
parent.makeDescendentsAvailable (this, availableDescendents);
/* update scrollbars */
int rightX = 0;
for (int i = 1; i < availableDescendents.length; i++) {
Rectangle bounds = availableDescendents [i].getBounds (false);
rightX = Math.max (rightX, bounds.x + bounds.width);
}
parent.updateHorizontalBar (rightX, rightX);
parent.updateVerticalBar ();
/*
* If new item is above viewport then adjust topIndex and the vertical scrollbar
* so that the current viewport items will not change.
*/
if (availableIndex < parent.topIndex) {
parent.topIndex += descendentsCount - 1;
ScrollBar vBar = parent.getVerticalBar ();
if (vBar != null) vBar.setSelection (parent.topIndex);
return;
}
int redrawStart = availableIndex + 1;
int redrawEnd = redrawStart + descendentsCount - 2;
parent.redrawItems (redrawStart, redrawEnd, false);
} else {
TreeItem[] descendents = computeAvailableDescendents ();
expanded = value;
if (availableIndex == -1) return;
Rectangle clientArea = parent.clientArea;
int y = parent.getItemY (this) + parent.itemHeight;
int startY = y + (descendents.length - 1) * parent.itemHeight;
if (y < clientArea.height && 0 < startY) { /* determine whether any visual update is actually needed */
if (parent.drawCount <= 0) {
parent.update ();
GC gc = new GC (parent);
gc.copyArea (0, startY, clientArea.width, clientArea.height - startY, 0, y);
gc.dispose ();
int redrawY = y + Math.max (0, clientArea.height - startY);
parent.redraw (0, redrawY, clientArea.width, clientArea.height - redrawY, false);
}
}
parent.makeDescendentsUnavailable (this, descendents);
/*
* If all collapsed items are above the viewport then adjust topIndex and
* the vertical scrollbar so that the current viewport items will not change.
*/
int bottomIndex = availableIndex + descendents.length - 1;
if (bottomIndex < parent.topIndex) {
parent.topIndex = parent.topIndex - descendents.length + 1;
ScrollBar vBar = parent.getVerticalBar ();
if (vBar != null) vBar.setSelection (parent.topIndex);
}
parent.updateHorizontalBar ();
parent.updateVerticalBar ();
/* move focus (and selection if SWT.SINGLE) to item if a descendent had focus */
TreeItem focusItem = parent.focusItem;
if (focusItem != null && focusItem != this && focusItem.hasAncestor (this)) {
parent.setFocusItem (this, false);
if ((parent.style & SWT.SINGLE) != 0) {
parent.selectItem (this, false);
}
/* Fire an event since the selection is being changed automatically */
Event newEvent = new Event ();
newEvent.item = this;
parent.sendEvent (SWT.Selection, newEvent);
if (isDisposed ()) return;
parent.showItem (this);
parent.redrawItem (availableIndex, true);
}
}
/* redraw the receiver's expander box */
if (isInViewport ()) {
Rectangle bounds = getExpanderBounds ();
parent.redraw (bounds.x, bounds.y, bounds.width, bounds.height, false);
}
}
/**
* Sets the font that the receiver will use to paint textual information
* for this item to the font specified by the argument, or to the default font
* for that kind of control if the argument is null.
*
* @param font the new font (or null)
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.0
*/
public void setFont (Font font) {
checkWidget ();
if (font != null && font.isDisposed ()) {
SWT.error (SWT.ERROR_INVALID_ARGUMENT);
}
Font oldFont = this.font;
if (oldFont == font) return;
this.font = font;
if (oldFont != null && oldFont.equals (font)) return;
Rectangle bounds = getBounds (false);
int oldRightX = bounds.x + bounds.width;
if ((parent.style & SWT.VIRTUAL) != 0) cached = true;
/* recompute cached values for string measurements */
GC gc = new GC (parent);
gc.setFont (getFont (false));
fontHeight = gc.getFontMetrics ().getHeight ();
computeDisplayTexts (gc);
computeTextWidths (gc);
gc.dispose ();
/* horizontal bar could be affected if tree has no columns */
if (parent.columns.length == 0) {
bounds = getBounds (false);
int newRightX = bounds.x + bounds.width;
parent.updateHorizontalBar (newRightX, newRightX - oldRightX);
}
redrawItem ();
}
/**
* Sets the font that the receiver will use to paint textual information
* for the specified cell in this item to the font specified by the
* argument, or to the default font for that kind of control if the
* argument is null.
*
* @param index the column index
* @param font the new font (or null)
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public void setFont (int columnIndex, Font font) {
checkWidget ();
if (font != null && font.isDisposed ()) {
SWT.error (SWT.ERROR_INVALID_ARGUMENT);
}
int validColumnCount = Math.max (1, parent.columns.length);
if (!(0 <= columnIndex && columnIndex < validColumnCount)) return;
if (cellFonts == null) {
if (font == null) return;
cellFonts = new Font [validColumnCount];
}
Font oldFont = cellFonts [columnIndex];
if (oldFont == font) return;
cellFonts [columnIndex] = font;
if (oldFont != null && oldFont.equals (font)) return;
if ((parent.style & SWT.VIRTUAL) != 0) cached = true;
/* recompute cached values for string measurements */
GC gc = new GC (parent);
gc.setFont (getFont (columnIndex, false));
if (fontHeights == null) fontHeights = new int [validColumnCount];
fontHeights [columnIndex] = gc.getFontMetrics ().getHeight ();
computeDisplayText (columnIndex, gc);
gc.dispose ();
if (isInViewport ()) {
Rectangle bounds = getCellBounds (columnIndex);
parent.redraw (bounds.x, bounds.y, bounds.width, bounds.height, false);
}
}
/**
* Sets the receiver's foreground color to the color specified
* by the argument, or to the default system color for the item
* if the argument is null.
*
* @param color the new color (or null)
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 2.0
*
*/
public void setForeground (Color color) {
checkWidget ();
if (color != null && color.isDisposed ()) {
SWT.error (SWT.ERROR_INVALID_ARGUMENT);
}
Color oldColor = foreground;
if (oldColor == color) return;
foreground = color;
if (oldColor != null && oldColor.equals (color)) return;
if ((parent.style & SWT.VIRTUAL) != 0) cached = true;
redrawItem ();
}
/**
* Sets the foreground color at the given column index in the receiver
* to the color specified by the argument, or to the default system color for the item
* if the argument is null.
*
* @param index the column index
* @param color the new color (or null)
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*
*/
public void setForeground (int columnIndex, Color value) {
checkWidget ();
if (value != null && value.isDisposed ()) {
SWT.error (SWT.ERROR_INVALID_ARGUMENT);
}
int validColumnCount = Math.max (1, parent.columns.length);
if (!(0 <= columnIndex && columnIndex < validColumnCount)) return;
if (cellForegrounds == null) {
if (value == null) return;
cellForegrounds = new Color [validColumnCount];
}
Color oldColor = cellForegrounds [columnIndex];
if (oldColor == value) return;
cellForegrounds [columnIndex] = value;
if (oldColor != null && oldColor.equals (value)) return;
if ((parent.style & SWT.VIRTUAL) != 0) cached = true;
if (isInViewport ()) {
redraw (
getTextX (columnIndex),
parent.getItemY (this),
textWidths [columnIndex] + 2 * MARGIN_TEXT,
parent.itemHeight,
columnIndex);
}
}
/**
* Sets the grayed state of the checkbox for this item. This state change
* only applies if the Tree was created with the SWT.CHECK style.
*
* @param grayed the new grayed state of the checkbox
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public void setGrayed (boolean value) {
checkWidget ();
if ((parent.getStyle () & SWT.CHECK) == 0) return;
if (grayed == value) return;
grayed = value;
if ((parent.style & SWT.VIRTUAL) != 0) cached = true;
if (isInViewport ()) {
Rectangle bounds = getCheckboxBounds ();
parent.redraw (bounds.x, bounds.y, bounds.width, bounds.height, false);
}
}
public void setImage (Image value) {
checkWidget ();
setImage (0, value);
}
/**
* Sets the image for multiple columns in the tree.
*
* @param images the array of new images
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_NULL_ARGUMENT - if the array of images is null</li>
* <li>ERROR_INVALID_ARGUMENT - if one of the images has been disposed</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public void setImage (Image[] value) {
checkWidget ();
if (value == null) error (SWT.ERROR_NULL_ARGUMENT);
// TODO make a smarter implementation of this
for (int i = 0; i < value.length; i++) {
if (value [i] != null) setImage (i, value [i]);
}
}
/**
* Sets the receiver's image at a column.
*
* @param index the column index
* @param image the new image
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_INVALID_ARGUMENT - if the image has been disposed</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public void setImage (int columnIndex, Image value) {
checkWidget ();
if (value != null && value.isDisposed ()) error (SWT.ERROR_INVALID_ARGUMENT);
TreeColumn[] columns = parent.columns;
int validColumnCount = Math.max (1, columns.length);
if (!(0 <= columnIndex && columnIndex < validColumnCount)) return;
Image image = getImage (columnIndex, false);
if (value == image) return;
if (value != null && value.equals (image)) return;
if (columnIndex == 0) {
super.setImage (value);
} else {
images [columnIndex] = value;
}
if ((parent.style & SWT.VIRTUAL) != 0) cached = true;
/*
* An image width change may affect the space available for the item text, so
* recompute the displayText if there are columns.
*/
if (columns.length > 0) {
GC gc = new GC (parent);
gc.setFont (getFont (columnIndex, false));
computeDisplayText (columnIndex, gc);
gc.dispose ();
}
if (value == null) {
redrawItem (); // TODO why the whole item?
return;
}
if (columns.length == 0) {
if (parent.imageHeight == 0) {
/* this is the first image being put into the parent Tree */
Rectangle bounds = value.getBounds ();
parent.orderedCol0imageWidth = bounds.width;
parent.setImageHeight (bounds.height);
parent.redrawItems (0, parent.availableItemsCount - 1, false);
} else {
redrawItem ();
}
return;
}
/* there are 1+ columns */
TreeColumn column = columns [columnIndex];
int orderedIndex = column.getOrderIndex ();
Rectangle bounds = value.getBounds ();
if (column.itemImageWidth == 0) column.itemImageWidth = bounds.width;
if (parent.imageHeight == 0) {
/* this is the first image being put into the parent Tree */
int oldItemHeight = parent.itemHeight;
parent.setImageHeight (bounds.height);
if (orderedIndex == 0) { /* the first ordered column */
parent.orderedCol0imageWidth = bounds.width;
/*
* All column 0 cells will now have less room available for their texts,
* so all items must now recompute their column 0 displayTexts.
*/
TreeItem[] rootItems = parent.items;
GC gc = new GC (parent);
for (int i = 0; i < rootItems.length; i++) {
rootItems [i].updateColumnWidth (column, gc);
}
gc.dispose ();
if (oldItemHeight != parent.itemHeight) {
/* the item height grew as a result of the new image height, so redraw everything */
parent.redraw ();
} else {
/* redraw the column since all items should now have image space */
parent.redraw (column.getX (), 0, column.width, parent.clientArea.height, false);
}
} else { /* not the first ordered column */
if (oldItemHeight != parent.itemHeight) {
/* the item height grew as a result of the new image height, so redraw everything */
parent.redraw ();
} else {
redrawItem ();
}
}
return;
}
if (orderedIndex == 0 && parent.orderedCol0imageWidth == 0) {
/* this is the first image being put into the current ordered column 0 */
parent.orderedCol0imageWidth = bounds.width;
/*
* All column 0 cells will now have less room available for their texts,
* so all items must now recompute their column 0 displayTexts.
*/
TreeItem[] rootItems = parent.items;
GC gc = new GC (parent);
for (int i = 0; i < rootItems.length; i++) {
rootItems [i].updateColumnWidth (column, gc);
}
gc.dispose ();
parent.redraw (column.getX (), 0, column.width, parent.clientArea.height, false);
return;
}
redrawItem (); // TODO why the whole item?
}
/**
* Sets the number of child items contained in the receiver.
*
* @param count the number of items
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.2
*/
public void setItemCount (int count) {
checkWidget ();
count = Math.max (0, count);
if (count == items.length) return;
int redrawStart, redrawEnd;
/* if the new item count is less than the current count then remove all excess items from the end */
if (count < items.length) {
redrawStart = count > 0 ? items [count - 1].availableIndex : availableIndex;
redrawEnd = parent.availableItemsCount - 1;
for (int i = count; i < items.length; i++) {
items [i].dispose (true);
}
if (count == 0) {
items = Tree.NO_ITEMS;
} else {
TreeItem[] newItems = new TreeItem [count];
System.arraycopy (items, 0, newItems, 0, count);
items = newItems;
}
if (count == 0) expanded = false;
} else {
int oldAvailableDescendentCount = computeAvailableDescendentCount ();
int grow = count - items.length;
redrawStart = items.length == 0 ? availableIndex : items [items.length - 1].availableIndex;
redrawEnd = expanded && isAvailable () ? parent.availableItemsCount + grow - 1: redrawStart;
TreeItem[] newItems = new TreeItem [count];
System.arraycopy (items, 0, newItems, 0, items.length);
items = newItems;
for (int i = items.length - grow; i < count; i++) {
items [i] = new TreeItem (this, SWT.NONE, i, false);
}
if (expanded && availableIndex != -1) {
/* expand the availableItems array if necessary */
if (parent.availableItems.length < parent.availableItemsCount + grow) {
TreeItem[] newAvailableItems = new TreeItem [parent.availableItemsCount + grow];
System.arraycopy (parent.availableItems, 0, newAvailableItems, 0, parent.availableItemsCount);
parent.availableItems = newAvailableItems;
}
TreeItem[] availableItems = parent.availableItems;
/* shift items right to create space for the new available items */
int dest = availableIndex + oldAvailableDescendentCount + grow;
System.arraycopy (
availableItems,
availableIndex + oldAvailableDescendentCount,
availableItems,
dest,
availableItems.length - dest);
parent.availableItemsCount += grow;
/* copy new items in */
System.arraycopy (
items,
items.length - grow,
availableItems,
availableIndex + oldAvailableDescendentCount,
grow);
/* update availableIndex for all affected items */
for (int i = availableIndex + oldAvailableDescendentCount; i < parent.availableItemsCount; i++) {
availableItems [i].availableIndex = i;
}
}
}
if ((parent.style & SWT.VIRTUAL) != 0) cached = true;
if (availableIndex != -1) {
if (expanded) parent.updateVerticalBar ();
parent.redrawItems (redrawStart, redrawEnd, false);
}
}
public void setText (String value) {
checkWidget ();
Rectangle bounds = getBounds (false);
int oldRightX = bounds.x + bounds.width;
setText (0, value);
/* horizontal bar could be affected if tree has no columns */
if (parent.columns.length == 0) {
bounds = getBounds (false);
int newRightX = bounds.x + bounds.width;
parent.updateHorizontalBar (newRightX, newRightX - oldRightX);
}
}
/**
* Sets the text for multiple columns in the tree.
*
* @param strings the array of new strings
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_NULL_ARGUMENT - if the text is null</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public void setText (String[] value) {
checkWidget ();
if (value == null) error (SWT.ERROR_NULL_ARGUMENT);
Rectangle bounds = getBounds (false);
int oldRightX = bounds.x + bounds.width;
// TODO make a smarter implementation of this
for (int i = 0; i < value.length; i++) {
if (value [i] != null) setText (i, value [i]);
}
/* horizontal bar could be affected if tree has no columns */
if (parent.columns.length == 0) {
bounds = getBounds (false);
int newRightX = bounds.x + bounds.width;
parent.updateHorizontalBar (newRightX, newRightX - oldRightX);
}
}
/**
* Sets the receiver's text at a column
*
* @param index the column index
* @param string the new text
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_NULL_ARGUMENT - if the text is null</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public void setText (int columnIndex, String value) {
checkWidget ();
if (value == null) error (SWT.ERROR_NULL_ARGUMENT);
int validColumnCount = Math.max (1, parent.columns.length);
if (!(0 <= columnIndex && columnIndex < validColumnCount)) return;
if (value.equals (getText (columnIndex, false))) return;
if (columnIndex == 0) {
super.setText (value);
} else {
texts [columnIndex] = value;
}
if ((parent.style & SWT.VIRTUAL) != 0) cached = true;
int oldWidth = textWidths [columnIndex];
GC gc = new GC (parent);
gc.setFont (getFont (columnIndex, false));
computeDisplayText (columnIndex, gc);
gc.dispose ();
if (availableIndex == -1) return;
if (parent.columns.length == 0) {
Rectangle bounds = getBounds (false);
int rightX = bounds.x + bounds.width;
parent.updateHorizontalBar (rightX, textWidths [columnIndex] - oldWidth);
}
if (isInViewport ()) {
redraw (
getTextX (columnIndex),
parent.getItemY (this),
Math.max (oldWidth, textWidths [columnIndex]) + 2 * MARGIN_TEXT,
parent.itemHeight,
columnIndex);
}
}
/*
* Perform any internal changes necessary to reflect a changed column width.
*/
void updateColumnWidth (TreeColumn column, GC gc) {
int columnIndex = column.getIndex ();
gc.setFont (getFont (columnIndex, false));
String oldDisplayText = displayTexts [columnIndex];
computeDisplayText (columnIndex, gc);
/* the cell must be damaged if there is custom drawing being done or if the alignment is not LEFT */
if (isInViewport ()) {
boolean columnIsLeft = (column.style & SWT.LEFT) != 0;
if (!columnIsLeft || parent.hooks (SWT.EraseItem) || parent.hooks (SWT.PaintItem)) {
Rectangle cellBounds = getCellBounds (columnIndex);
parent.redraw (cellBounds.x, cellBounds.y, cellBounds.width, cellBounds.height, false);
} else {
/* if the display text has changed then the cell text must be damaged in order to repaint */
if (oldDisplayText == null || !oldDisplayText.equals (displayTexts [columnIndex])) {
Rectangle cellBounds = getCellBounds (columnIndex);
int textX = getTextX (columnIndex);
parent.redraw (textX, cellBounds.y, cellBounds.x + cellBounds.width - textX, cellBounds.height, false);
}
}
}
for (int i = 0; i < items.length; i++) {
items [i].updateColumnWidth (column, gc);
}
}
/*
* The parent's font has changed, so if this font was being used by the receiver then
* recompute its cached text sizes using the gc argument. Pass this notification on to
* all child items as well.
*/
void updateFont (GC gc) {
if (font == null) { /* receiver is using the Tree's font */
computeDisplayTexts (gc);
computeTextWidths (gc);
}
/* pass notification on to all children */
for (int i = 0; i < items.length; i++) {
items [i].updateFont (gc);
}
}
}